{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 支持向量机介绍\n",
    "\n",
    "对两类样本点进行分类，如下图，有a线、b线、c线三条线都可以将两类样本点很好的分开类，我们可以观察到b线将两类样本点分类最好，原因是我们训练出来的分类模型主要应用到未知样本中，虽然a、b、c三条线将训练集都很好的分开类，但是当三个模型应用到新样本中时，b线抗干扰能力最强，也就是泛化能力最好，样本变化一些关系不大，一样能被正确的分类。那么如何确定b线的位置呢？我们可以使用支持向量机SVM来确定b线的位置。\n",
    "\n",
    "![image.png](https://i-blog.csdnimg.cn/blog_migrate/ea13ebf41532b433b995040d995dc071.png#pic_center)\n",
    "\n",
    "支持向量机(support vector machine,SVM) 是一种二分类算法，它的目的是寻找一个超平面来对样本进行分割，分割的原则是间隔最大化，如果对应的样本特征少，一个普通的 SVM就是一条线将样本分隔开，但是要求线到两个类别最近样本点的距离要最大。\n",
    "\n",
    "![image.png](https://i-blog.csdnimg.cn/blog_migrate/018783eca2545866676099529f2d6ac7.png#pic_center)\n",
    "\n",
    "如上图所示，b 线就是我们根据支持向量机要找到的分割线，这条线需要到两个类别最近的样本点最远，图上的距离就是 d,由于这条线处于两个类别的中间，所以到两个类别的距离都是 d。\n",
    "  支持向量机SVM算法就是在寻找一个最优的决策边界（上图中的两条虚线）来确定分类线b，所说的支持向量（support vector）就是距离决策边界最近的点（上图中p1、p2、p3点，只不过边界穿过了这些点）。如果没有这些支持向量点，b线的位置就要改变，所以SVM就是根据这些支持向量点来最大化margin，来找到了最优的分类线（machine，分类器），这也是SVM分类算法名称的由来。\n",
    "\n",
    "[知识补充]\n",
    "二维空间$(x_1,x_2)$到直线$Ax+By+C=0$的距离公式为：\n",
    "$$ d = \\frac{|Ax_1+By_1+C|}{\\sqrt{A^2+B^2}} $$\n",
    "两条平行线$Ax+By+C_1=0$和$Ax+By+C_2=0$之间的距离公式为:\n",
    "$$ d  = \\frac{|C_1-C_2|}{\\sqrt{A^2+B^2}} $$\n",
    "\n",
    "我们希望 是决策边界上的样本点到$l_2$直线的距离 $d$ 越大越好。我们可以直接计算$l_1$或$l_3$上的点到直线$l_2$的距离，假设将空间点扩展到 n维空间后，点 $x_i = (x_1,x_2,\\cdots,x_n)$ 到直线$w^T\\cdot x + b = 0$的距离为：\n",
    "$$ d = \\frac{|w^T\\cdot x_i + b|}{||w||} $$\n",
    "以上$||w|| = \\sqrt{w_1^2+w_2^2+\\cdots+w_n^2}$, 读作“W的模”。\n",
    "  \n",
    "  由于$l_1$、$l_2$、$l_3$是平行的，d也是两条平行线之间的距离，我们根据两条平行线之间的距离公式到d如下：\n",
    "$$ d = \\frac{|C-0|}{||w||} = \\frac{|-C-0|}{||w||} = \\frac{C}{||w||}=\\frac{w^T\\cdot x_i + b}{||w||} $$\n",
    "\n",
    "我们可以看到五路计算点到直线的距离还是两个平行线之间的距离，最终结果是一致的。对于$l_1$直线，我们可以先对应成比例的$w^T \\cdot +b =  c$ 缩小各项系数，例如变成 $\\frac{w^T}{2} \\cdot + frac{b}{2} = \\frac{c}{2} $，这条直线还是原本身的直线，现在我们可以把他变成 $\\frac{w^T}{c} \\cdot + frac{b}{c} = \\frac{c}{c} = 1$ 即改写后的$l_3$直线 $w^T \\cdot x+b = 1$,还是原来的直线 ,同理，对于$l_1$直线我们也可以变成$w^T \\cdot x+b = -1$,所以上图可以改变成如下:\n",
    "![image.png](https://i-blog.csdnimg.cn/blog_migrate/46a087b4d13cf457fdbeff95f224bf55.png#pic_center)\n",
    "\n",
    "那么变换后的 d 可以根据两条平行线之间的距离得到:\n",
    "$$ d = \\frac{|1|}{||w||} = \\frac{1}{||w||}$$\n",
    "\n",
    "我们希望决策边界熵的点到超平面$l_2$距离$d$越大越好。我们将$l_3$上方的点分类标记为“1”类别，将$l_1$下方的点分类标记为\"-1\"类别，那么我们可以得到如下公式:\n",
    "\n",
    "$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 构建SVM 目标函数\n",
    "\n",
    "接着上面的分类问题来分析，假设致辞向量机最终要找到线 $l_2$,决策边界两条线是$l_1$和 $l_3$,那么$l_2$的方程为$w^T\\cdot x+b=0$,这里 $w$表示$(w_1,w_2)^T$,x 表示$(x_1,x_2)^T$, 我们想要确定 $l_2$直线，只需要确定 $w$和$b$即可，此外，由于$l_1$和 $l_3$的决策分类边界线，一定与$l_2$是平行的，平行就意味着斜率不变，$b$变化即可，所以我们可以假设线$l_1$的方程$w^T \\cdot x+b = c$ ,$l_3$的方程$w^T \\cdot x+b = -c$, "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 拉格朗日乘数法、KKT条件、对偶"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 拉格朗日乘数法\n",
    "\n",
    "  拉格朗日乘数法主要是将有等式约束条件优化问题转换为无约束优化问题，拉格朗日乘数法如下：\n",
    "假设$x = [1,2,3, \\cdots, n]$是一个 $n$ 维向量。$f(x)$包含$h(x)$的函数，我们需要找到 $h(x)=0$的条件下$f(x)$的最小值。如下:\n",
    "$$ \\min f(x) st. h(x) = 0 $$\n",
    "可以引入一个变量 $\\lambda$ ，其中$\\lambda$ 可以取任意值。则上方式可以表示为\n",
    "$$ L(x, \\lambda) = f(x) + \\lambda h(x) $$\n",
    "其中$L(x, \\lambda)$是拉格朗日函数。$\\lambda$ 是拉格朗日乘子，也就是拉格朗日系数。令$L(x, \\lambda)$对$x$ 求导数等于 0，对$\\lambda$求导数等于0，求解除$x,\\lambda$,那么$x$就是函数$f(x)$在附件函数$h(x)$下的极致点。\n",
    "[参考](https://blog.csdn.net/Soft_Po/article/details/118332454)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## KKT 条件\n",
    "\n",
    "假设 $x = [1,2,3,\\cdot,n]$是一个$n$维的向量，$f(x)$和 $h(x)$ 是一个包含$x$的函数。我们需要找到$h(x) leq 0$ 条件下的$h(x)$的最小值，如下:\n",
    "$$ \\min f(x) ,st. h(x) \\leq 0 \\tag{\\textcircled{1}}$$\n",
    "\n",
    "针对上式，显然是一个不等式约束最优化问题，不能再使用拉格朗日乘数法，因为拉格朗日乘数法是针对等式约束最优化问题。\n",
    "但是我们可以考虑将这种不等式转换成等式来处理，这儿可以考虑引入一个:“松弛变量”$a^2$，使得:$h(x) \\leq 0$效果等效。那么条件就会变成 $h(x) + a^2 = 0$。这里$a^2$保证加的是一个非负数，即$a^2 \\geq 0$。但是目前不知道多少，需要找到一个合适的$a^2$ 使得$h(x) + a^2 = 0$成立。如下:\n",
    "$$ \\min f(x)  ,st. h(x) + a^2 = 0 \\tag{\\textcircled{2}}$$\n",
    "\n",
    "转化成拉格朗日行数:\n",
    "$$ L(x,\\lambda,a^2) = f(x) + \\lambda(a^2 + h(x)) $$\n",
    "\n",
    "上式中，$\\lambda$必须满足 $\\lambda \\geq 0$,由于 $L(x,\\lambda,a)$变成了一个有条件的拉格朗日函数。这里要求 $minL(x,\\lambda,a)$对应的$x$。至于为什么$\\lambda \\geq 0$,为什么计算的是$minL(x,\\lambda,a)$而不是$minL(x,a)$,这里就不展开了。[参考](https://blog.csdn.net/Soft_Po/article/details/118358564)。\n",
    "所以将上式转成拉格朗日函数如下:\n",
    "$$ min L(x,\\lambda,a) =  f(x)+\\lambda(a^2+h(x)),\\lambda \\geq 0 \\tag{\\textcircled{3}}$$\n",
    "\n",
    "  以上我们可以看到将不等式条件约束优化问题加入“松弛变量”转换成等式条件约束优化问题，使用拉格朗日乘数法进行转换得到$L(x,\\lambda,a)$,我们先抛开 $min$ 下面我们将对拉格朗日函数求偏导。\n",
    "$$\\frac{\\partial L}{\\partial x} = \\frac{\\partial f(x)}{\\partial x} +\\lambda\\cdot\\frac{\\partial h(x)}{\\partial x}=0 \\tag{\\textcircled{4}} $$\n",
    "$$\\frac{\\partial L}{\\partial \\lambda} =h(x)+a^2=0  \\tag{\\textcircled{5}}$$\n",
    "$$\\frac{\\partial L}{\\partial a} = {2}{\\lambda}{a}=0  \\tag{\\textcircled{6}}$$\n",
    "$$ \\lambda \\geq 0 \\tag{\\textcircled{7}}$$\n",
    "\n",
    "由式6可知道 $\\lambda{a}=0$可以，有两种情况\n",
    "1) $\\lambda =0 ,a \\neq 0$\n",
    "<br>\n",
    " 由于$\\lambda=0$,跟据 $\\textcircled{3}$ 式可知，** 约束条件不起作用 ** 根据$\\textcircled{1}$可知$h(x) \\leq 0$。\n",
    "2) $\\lambda \\neq 0,a = 0$\n",
    "<br>\n",
    "由于$\\lambda \\neq 0$,根据$\\textcircled{3}$可知$\\lambda \\geq 0$。由于$a=0$ ** 约束条件起作用 ** ,根据 $\\textcircled{5}$可知 $h(x)=0$。\n",
    "\n",
    "综上所述，$\\lambda \\cdot a =0$,且约束条件起作用时，$\\lambda \\geq 0，h(x)=0$; 约束条件不起作用时，$\\lambda =0，h(x) \\neq 0$。\n",
    "\n",
    "上面方程组中的$\\textcircled{6}$ 可以改写成 $\\lambda \\cdot h(x) = 0$。由于 $a^2>0$,所以将$\\textcircled{5}$改写成$h(x)<0$。返程转化如下:\n",
    "$$\\begin{cases}\n",
    "\\frac{\\partial L}{\\partial x} = \\frac{\\partial f(x)}{\\partial x}+\\lambda \\cdot \\frac{\\partial h(x)}{\\partial x} = 0 \\\\\n",
    "\n",
    "h(x) \\leq 0 \\\\\n",
    "\n",
    "\\lambda \\cdot h(x) = 0 \\\\\n",
    "\n",
    "\\lambda \\geq 0 \\\\\n",
    "\n",
    "\\end{cases} $$\n",
    "\n",
    "  <font color='red'>以上便是不等式约束优化问题的KKT（Karush-Kuhn-Tucker）条件</font>，我们回到最开始要处理的问题上，根据③式可知，我们需要找到合适的且满足 kkt 条件的 $x,\\lambda,a$值使得 $L(x,\\lambda,a)$ 最小。\n",
    "\n",
    "我们对于$\\textcircled{3}$可以进一步优化:\n",
    "$$ \\begin{cases}\n",
    "min L(x,\\lambda,a) = f(x)+\\lambda  (h(x)+a^2),\\lambda \\geq 0 \\tag{\\textcircled{3}} \\\\\n",
    "min L(x,\\lambda,a) = f(x)+\\lambda  h(x)+\\lambda  a^2)\n",
    "\\end{cases} $$\n",
    "\n",
    "由于$a^2 和 \\lambda \\geq 0$,所以 $\\lambda a^2$ 一定大于 0\n",
    "$$ min L(x,\\lambda,a) = f(x)+\\lambda h(x) \\tag{\\textcircled{8}}$$\n",
    "\n",
    "满足$\\textcircled{8}$条件的$x,\\lambda,a$值一定满足 kkt 条件。假设我们现在找到了合适的参数$x$,使得 $f(x)$取得最小值$P$,[注意: 这里更具$\\textcircled{1}$来说，计算$f(x)$的最小值，这里假设合适参数$x$对应$f(x)$取得最小值$P$，不存在更小的]。\n",
    "由于$\\textcircled{8}$中一定小于或等于0，所以一定有：\n",
    "$$ L(x,\\lambda,a) = f(x)+\\lambda h(x) \\leq P $$\n",
    "也就是说:\n",
    "$$ L(x,\\lambda) \\leq P $$\n",
    "\n",
    "为了找到最优的$\\lambda$的值，我们一定要想$L(x,\\lambda)$接近$P$,即找到合适的$\\lambda$最大化，可以写成$max_{\\lambda} L(x,\\lambda)$。所以$\\textcircled{8}$ 可以写成:\n",
    "$$ \\min_x \\max_{\\lambda} L(x,\\lambda) ,st . \\lambda \\geq 0  \\tag{\\textcircled{9}}$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 对偶问题\n",
    "\n",
    "对偶问题是我们定义的一种问题，对于一个不等于约束的原问题:\n",
    "$$ \\min_{x} \\max_{\\lambda} , st. \\lambda \\geq 0$$\n",
    "\n",
    "我们定义对偶问题为(对上面方程的求解等效求解下面的方程):\n",
    "$$ \\max_{\\lambda}\\min_{x} , st. \\lambda \\geq 0$$\n",
    "其实就是把min和max对调了一下，当然对应的变量也要变换。\n",
    "对偶问题有什么好处呢？对于原问题，我们要先求里面的max，再求外面的min。而对于对偶问题，我们可以先求里面的min。有时候，先确定里面关于$x$的函数最小值，比原问题先求解关于 $\\lambda$的最大值，要更加容易解。\n",
    "\n",
    "但是原问题跟对偶问题并不是等价的，这里有一个强对偶性、弱对偶性的概念，弱对偶性是对于所有的对偶问题都有一个性质。\n",
    "弱对偶性的推到过程:\n",
    "\n",
    "* $$ \\max_{\\lambda}\\min_{x} = \\min_{\\lambda} L(x,\\lambda^\\star) \\leq L(x^\\star,\\lambda^\\star) \\leq \\max_{\\lambda}L(x^\\star,\\lambda) = \\min_{x}\\max_{\\lambda} L(x,\\lambda)    $$\n",
    "其中 $x^\\star,\\lambda^{\\star}$ 是函数取最大值最小值的时候对应的最优解，也就是说，原问题始终大于等于对偶问题:\n",
    "* $$ \\max_{\\lambda} \\min_{x} L(x,\\lambda) \\leq \\min_{x}\\max_{\\lambda}L(x,\\lambda)$$\n",
    "如果两个问题强对偶，那么两个问题其实是等价的问题:\n",
    "* $$ \\max_{\\lambda} \\min_{x} L(x,\\lambda) = \\min_{x}\\max_{\\lambda}L(x,\\lambda)$$\n",
    "\n",
    "$$ \\max_{\\lambda} \\min_{x} L(x,\\lambda) \\leq \\min_{x}\\max_{\\lambda}L(x,\\lambda)$$\n",
    "\n",
    "【备注】：对弱对偶性推导的理解如下图所示：\n",
    "\n",
    "![image.png](https://i-blog.csdnimg.cn/blog_migrate/6c3477dbdd9d914f2db83eced9fe928e.png#pic_center)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 最小化SVM目标函数\n",
    "\n",
    "通过 第二节我们知道 SVM 目标函数如下:\n",
    "$$ min \\frac{1}{2} ||w||^2 , st. y\\cdot(w^T\\cdot{x_i}+b) \\geq 1,i=1,2,...,n$$\n",
    "\n",
    "  根据拉格朗日乘数法、KKT条件、对偶问题我们可以按照如下步骤来计算SVM目标函数最优的一组w值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构造拉格朗日函数\n",
    "\n",
    "\n",
    "将 SVM 目标函数转换为如下:\n",
    "* $$ \\min \\frac{1}{2}||w||^2, st \\ \\   { 1-y\\cdot(w^T\\cdot x+b) \\leq 1, i=1,2,3,...,n }$$\n",
    " 根据 3.2 中的 $\\textcircled{9}$ 式，可以得到拉格朗日函数:\n",
    "* $$ \\min_{w,b}\\max_{\\lambda}L(w,b,\\lambda) = \\frac{1}{2}||w||^2+\\sum_{i=1}^{n}\\lambda_i[1-y_i(w^T\\cdot{x_i}+b)] ,s.t.\\  \\lambda_i \\geq 0 \\tag{\\textcircled{a}}$$\n",
    "  以上不等式转换成拉格朗日函数必须满足KKT条件，详见3.2 KKT条件，这里满足的KKT条件如下：\n",
    "$$ \\begin{cases}\n",
    "1-y_i \\cdot (w^T\\cdot{x_i}+b) \\leq 0 \\\\\n",
    "\\lambda \\cdot (1-y_i \\cdot (w^T\\cdot{x_i}+b)) =0 \\\\\n",
    "\\lambda \\geq 0 \n",
    "\\end{cases} $$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 对偶转换\n",
    "\n",
    "由于原始目标函数$\\frac{1}{2}||w||^2$ 是个凸函数，根据 3.3中对偶问题可知$L(w,b,\\lambda)$ 一定是个强对偶问题，所以可以将$\\textcircled{a}$改成如下:\n",
    "$$ \\max_{\\lambda}\\min_{w,b}L(w,b,\\lambda) = \\frac{1}{2}||w||^2+\\sum_{i=1}^{n}\\lambda_i[1-y_i(w^T\\cdot{x}+b)] ,s.t. \\ \\lambda_i \\geq 0 \\tag{\\textcircled{b}}$$\n",
    "\n",
    "正对 $b$式，我们假设参数$\\lambda$固定，式$L(w,b,\\lambda)$ 对参数$w$和$b$进行求导得到如下:\n",
    "\n",
    "$$ \\begin{cases}\n",
    "\\frac{\\partial L}{\\partial w} = w-\\sum_{i=1}^{n}\\lambda_i\\cdot{x_i}\\cdot{y_i}= 0 \\\\\n",
    "\n",
    "\\frac{\\partial L}{\\partial b} = \\sum_{i=1}^{n}\\lambda_i\\cdot{y_i} = 0\n",
    "\\end{cases} $$\n",
    "\n",
    "进一步可以得到:\n",
    "\n",
    "$$ \\begin{cases}\n",
    "\\sum_{i=1}^{n}\\lambda_i\\cdot{x_i}\\cdot{y_i} =w \\\\ \n",
    "\\sum_{i=1}^{n}\\lambda_i\\cdot{y_i} =0  \n",
    "\\tag{\\textcircled{c}} \\end{cases} $$\n",
    "\n",
    "按照解方程组的思想，我们现将以上计算得到的结果带入到$b$式中，得到:\n",
    "$$\\begin{align} \n",
    "\\max_{\\lambda}L(w,b,\\lambda) = \\frac{1}{2}||w||^2+\\sum_{i=1}^{n}\\lambda_i[1-y_i(w^T\\cdot{x}+b)] \\\\\n",
    "=\\frac{1}{2}\\cdot \\sum_{i=1}^{n}\\sum_{j=1}^{n}\\lambda_i\\lambda_j{y_i}{y_j}(x_i\\cdot x_j)+\\sum_{i=1}^{n}\\lambda_i-\\sum_{i=1}^{n}\\lambda_i{y_i}(\\sum_{j=1}^{n}\\lambda_j{x_i}{y_j}+b) \\\\\n",
    "=\\frac{1}{2}\\cdot \\sum_{i=1}^{n}\\sum_{j=1}^{n}\\lambda_i\\lambda_j{y_i}{y_j}(x_i\\cdot x_j)+\\sum_{i=1}^{n}\\lambda_i-\\frac{1}{2}\\cdot \\sum_{i=1}^{n}\\sum_{j=1}^{n}{\\lambda_i}{y_i}{\\lambda_j}{y_j}(x_i\\cdot x_j)-\\sum_{i=1}^{n}{\\lambda_i}{y_i}{b} \\\\\n",
    "=\\sum{i=1}^{n}{\\lambda_i}-\\frac{1}{2}{\\cdot}{\\sum_{i=1}^{n}}{\\sum_{j=1}^{n}{\\lambda_i}{\\lambda_j}{y_i}{y_j}{x_i}{x_j}} ,s.t. \\sum_{i=1}^{n}{\\lambda_i}{y_i} \\geq 0{\\lambda_i} \\geq 0 \\\\\n",
    "\n",
    "\\tag{\\textcircled{d}} \\end{align}\n",
    "$$\n",
    "化简得到:\n",
    "\n",
    "$$\\begin{align}\n",
    "\\max_{\\lambda}L(w,b,\\lambda) = \\max_{\\lambda}[\\sum_{i=1}{n}{\\lambda_i}-\\frac{1}{2}{\\cdot}{\\sum_{i=1}^{n}}{\\sum_{j=1}^{n}{\\lambda_i}{\\lambda_j}{y_i}{y_j}{x_i}{x_j}}],s.t.\\sum_{i=1}^{n}{\\lambda_i}{y_i} \\geq 0{\\lambda_i} \\geq 0 \\tag{\\textcircled{d}}\n",
    "\\end{align} $$\n",
    "\n",
    "我们可以发现以上公式经过转换只含有$\\lambda$的方程求极值问题，但是$\\lambda$包含$\\lambda_i,\\lambda_j,...$ 这些未知数，那么我们要求的一组$w$如何得到呢? 只要正对以上公式得到$\\lambda$后，我们可以更具$\\textcircled{c}$式求解出$w$。针对上式求极值问题，我们通常用SMO(Sequential Minimal OPtimization)算法来求解。\n",
    "注意: $\\textcircled{d}$中的${x_i\\cdot x_j}$ 代表两个向量的点积，也叫内积: $ x_i = (x_{i1},x_{i2}),x_j = (x_{j1},x_{j2})$ 那么两个向量点积结果为:$x_{i1}{\\cdot}x_{j1}+x_{i2}{\\cdot}x_{j2} $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SMO算法求解\n",
    "  SMO(Sequential Minimal Optimization)，序列最小优化算法，其核心思想非常简单：**每次只优化一个参数，其他参数先固定住，仅求当前这个优化参数的极值**。下面我们只说SVM中如何利用SMO算法进行求解最终结果的，这里不再进行公式推导。\n",
    "\n",
    "$$ \\max_{\\lambda}L(w,b,\\lambda) = \\max_{\\lambda}[\\sum_{i=1}^{n}\\lambda_i-\\frac{1}{2}{\\cdot}\\sum_{i=1}^{n}\\sum_{j=1}^{n}\\lambda_i\\lambda_jy_iy_j(x_i \\cdot x_j)]  \\tag{\\textcircled{d}},s.t.\\ \\sum_{i=1}^{n} $$\n",
    "\n",
    "我们更具 $\\textcircled{d}$ 式，我们可以看到有$\\lambda_i,\\lambda_j,i=1,2,...,n$ 很多参数，由于优化目标中含有约束条件：$\\sum_{i=1}^{n}\\lambda_iy_i=0$，此约束条件中$i=1,2,3,...,n$,$y_i$代表每个样本类别-1 或者 1。\n",
    "根据 SMO 算法假设$\\lambda,\\lambda_3,\\lambda_4,\\cdots$ 参数固定，那么$\\lambda_1,\\lambda_2$ 之间的关系也确定了，可以将约束条件:$\\sum_{i=1}^{n}\\lambda_i y_i=0$改写成:\n",
    "$$ \\lambda_1 y_1+\\lambda_2 y_2+c=0 \\tag{\\textcircled{e}} $$\n",
    "我们将式中$c$看成$\\lambda_3,\\lambda_4,\\cdots,\\lambda_n$诚意对应的类别$y$得到的常数，根据$\\textcircled{e}$式，我们可以发现$\\lambda_1,\\lambda_2$ 之间的关系，即：$\\lambda_2 = \\frac{-c-\\lambda_1 y_1}{y_2}$。 也就是说我们可以使用$\\lambda_1$的表达式代替$\\lambda_2$,这样我们就可以将$\\textcircled{d}$式看成只含有$\\lambda_1 \\geq 0$ 这一个条件下最优化问题，并且我们可以将$\\lambda_2 = \\frac{-c-\\lambda_1 y_1}{y_2}$代入到$\\textcircled{d}$式中，$d$式中只含有$\\lambda_1$一个未知数求极值问题，可以对函数进行求导，令导数为 0，得到$\\lambda_1$的值，然后根据$\\lambda_1$的值计算出$\\lambda_2$的值。通过以上固定参数方式多次迭代计算得到一组$\\lambda$值。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 计算分割线 w和 b的值\n",
    "\n",
    "根据 4.2中$\\textcircled{c}$式，如下:\n",
    "$$ \\begin{cases}\n",
    "\\sum_{i=1}^{n}\\lambda_i\\cdot{x_i}\\cdot{y_i} =w \\\\ \n",
    "\\sum_{i=1}^{n}\\lambda_i\\cdot{y_i} =0  \n",
    "\\tag{\\textcircled{c}} \\end{cases} $$\n",
    "我们可以知道获取一组$\\lambda$的值，我们可以得到一组$w$对应的值。更具 4.1 中 KKT 条件:\n",
    "$$ \\begin{cases}\n",
    "1-y_i \\cdot (w^T\\cdot{x_i}+b) \\leq 0 \\\\\n",
    "\\lambda \\cdot (1-y_i \\cdot (w^T\\cdot{x_i}+b)) =0 \\\\\n",
    "\\lambda \\geq 0  \\tag{\\textcircled{f}}\n",
    "\\end{cases} $$\n",
    "\n",
    "根据$\\textcircled{f}$式，我们可知，当$\\lambda \\geq=0$时，一定有$1-y_i \\cdot (w^T \\cdot x_i+b) = 0$,对于这样的样本就属于支持向量点，就在分类边界上，我们将对应的$w$带入到下式中\n",
    "$$ y_i \\cdot (w^T \\cdot x_i+b) = 1 \\tag{\\textcircled{g}}$$\n",
    "一定可以计算出$b$的值，我们将$g$式两边诚意$y_i$，可得:\n",
    "$$ y_i^2 \\cdot (w^T \\cdot x_i + b ) = y_i $$\n",
    "由于$y_i^2 = 1$ 所以得到最终的$b$的结果如下:\n",
    "$$ b = y_i - w^T \\cdot x_i $$\n",
    "\n",
    "假设我们有$S$个支持向量，以上$b$的计算可以使用任意一个支持向量带入计算即可，如果数据严格式线性可分的，这些$b$结果是一致的，对于数据不是严格线性可分的情况，参照后面的软间隔问题，一般我们可以采用一种更健壮的方式，将所有致辞向量对应的$b$都求出，然后将其平均值作为最后的结果，最终$b$的结果如下:\n",
    "$$ b = \\frac{1}{|S|}\\sum_{i\\in S}y_i - w^T \\cdot x_i $$\n",
    "\n",
    "$S$为支持向量的集合，也就是在边界上点的集合。\n",
    "综上所述，我们可以得到最终的$w$和$b$的值如下:\n",
    "$$ \\begin{cases}\n",
    "w= \\sum_{i=1}^{n}\\lambda_i\\cdot{x_i}\\cdot{y_i} \\\\ \n",
    "b = \\frac{1}{|S|}\\sum_{i\\in S}y_i - w^T \\cdot x_i \n",
    "\\end{cases} $$\n",
    "\n",
    "确定$w$和$b$之后，我们就能构造出最大分割超平面:$w^T \\cdot x+b=0$，新来样本对应的特征带入后得到的结果如果是大于 0 那么属于一类，小于 0 属于另一类。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 软间隔及其优化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 软间隔问题\n",
    "\n",
    "以上讨论问题都是基于样本完全的线性可分，我们称为硬间隔如下图:\n",
    "![image.png](https://i-blog.csdnimg.cn/blog_migrate/bf7dc5000ff600bba35862322288d7b9.png#pic_center)\n",
    "\n",
    "如果存在样本点不能完全线性可分，大部分样本线性可分的情况，如下图所示:\n",
    "![image.png](https://i-blog.csdnimg.cn/blog_migrate/37b89d14ea45f2940c06d4e2c48f40a5.png#pic_center)\n",
    "\n",
    "  那么我们就需要用到软间隔，相比于硬间隔的苛刻条件，我们允许个别样本点出现在间隔带里面，比如：\n",
    "![image.png](https://i-blog.csdnimg.cn/blog_migrate/6a4c34250594f50b48f3e4cf02973f21.png#pic_center)\n",
    "\n",
    "  即我们允许部分样本点不满足约束条件：\n",
    "$$ y \\cdot (w^T x + b) \\geq 1 $$\n",
    "\n",
    "为了度量这个间隔软到何种程度，我们为每个样本引入了一个\"松弛变量“ $\\xi_i,\\xi_i \\geq 0$，(中文:克西） 加入松弛变量后，我们的约束条件变成$y \\cdot (w^T x + b + \\xi_i) \\geq 1$，这样不等式就不会那么严格，数据点在不同的约束条件下的情况如下:\n",
    "![image.png](https://i-blog.csdnimg.cn/blog_migrate/7a528964c2f389f59f81bf8f06b17436.png#pic_center)\n",
    "\n",
    "* 内部点: $y_i \\cdot (w^T x_i + b) \\geq 1,即 \\xi_i = 0$\n",
    "* 边界点: $y_i \\cdot (w^T x_i + b) = 1,即\\xi_i = 0$\n",
    "* 外部点: $y_i \\cdot (w^T x_i + b) = 1-\\xi_i，即 0 < \\xi_i < 1$\n",
    "* 错误误差点：$y_i \\cdot (w^T x_i + b) = 1-\\xi_i ,即  \\xi_i \\geq 1$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 优化SVM目标函数\n",
    "\n",
    "  加入软间隔后我们的目标函数变成了：\n",
    "\n",
    "$$ \\min_\\frac{1}{2}||w||^2+C\\sum_{i=1}^m\\xi_i ,s.t. \\ 1-y \\cdot (w^T \\cdot x_i + b) - \\xi_i \\leq 0 ,i=1,2,3,...,n \\tag{\\textcircled{h}}$$\n",
    "\n",
    "其中$C$式一个大于0的常数，这里在原有的目标函数中加入$C\\sum_{i=1}{n}\\xi_i$ 可以理解为错误样本的惩罚程度，我们希望在对应条件下$\\min \\frac{1}{2}||w||^2+C\\sum_{i=1}{n}\\xi_i$变小，对应的也希望$C\\sum_{i=1}{n}\\xi_i$变小，当$C$无穷大，$\\xi_i$必然无穷小，这样的话 SVM就变成一个完全线性可分的 SVM。如果 $C$为有对应的值时，$\\xi_i$就对应会有一个大于0 的值，这样的 SVM 就是允许部分样本不遵守约束条件。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SVM代码"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 网格搜索"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SVM Hinge Loss 损失函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 核函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 非线性SVM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 核函数(Kernel Function)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 核函数在 SVM 中的应用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 支持向量机SVM 特点"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 抗干扰能力强"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 二分类及多分类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 代码案例"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SVM核函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "from sklearn import datasets\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import train_test_split\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(142, 13)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 加载数据\n",
    "X,y = datasets.load_wine(return_X_y=True)\n",
    "X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2)\n",
    "display(X_train.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 线性核函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.87898096,  0.57382273,  1.31304463, -0.20446441,  0.00820465,\n",
       "        -0.02831571,  0.2830166 ,  0.25124208, -0.14474783,  0.49130059,\n",
       "        -0.16468766,  0.56257614,  0.00427838],\n",
       "       [ 0.01511131, -0.00642277,  0.07340351, -0.1733655 ,  0.03272674,\n",
       "         0.23506808,  0.46624798, -0.02240921,  0.08104595, -0.16748047,\n",
       "         0.07629076,  0.31332221,  0.00188012],\n",
       "       [-0.26549649, -0.41819432, -0.28493303, -0.23688386,  0.04543909,\n",
       "        -0.01365888,  0.70261536, -0.01649627,  0.15644085, -1.0619252 ,\n",
       "         0.15673037,  0.26267403, -0.00470569]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([-19.86367464,  -3.19723036,  11.52589669])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(None, 0.0)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svc = SVC(kernel='linear')\n",
    "svc.fit(X_train, y_train)\n",
    "svc.score(X_test, y_test)\n",
    "display(svc.coef_,svc.intercept_),svc.coef0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 高斯核函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6666666666666666"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svc = SVC(kernel='rbf')\n",
    "svc.fit(X_train, y_train)\n",
    "svc.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 多项式核函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6944444444444444"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svc = SVC(kernel='poly',degree=2,coef0=0)\n",
    "svc.fit(X_train, y_train)\n",
    "svc.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sigmoid函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.16666666666666666"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svc = SVC(kernel='sigmoid')\n",
    "svc.fit(X_train, y_train)\n",
    "svc.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 非线性核函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import ListedColormap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x120a60f50>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X,y = datasets.make_circles(n_samples=100, factor=0.5, noise=0.03)\n",
    "plt.figure(figsize=(6,6))\n",
    "c  = ListedColormap(['blue', '#FF0000'])\n",
    "plt.scatter(X[:,0],X[:,1],c= y,cmap=c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 线性核函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.55"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svc = SVC(kernel='linear')\n",
    "svc.fit(X, y)\n",
    "svc.score(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### poly[升维]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svc = SVC(kernel='poly',degree=2)\n",
    "svc.fit(X, y)\n",
    "svc.score(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### rbf[高斯核函数]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svc = SVC(kernel='rbf')\n",
    "svc.fit(X, y)\n",
    "svc.score(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sigmoid函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.51"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svc = SVC(kernel='sigmoid')\n",
    "svc.fit(X, y)\n",
    "svc.score(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 核函数在回归中的应用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 创建数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建数据\n",
    "import numpy as np\n",
    "from sklearn.svm import SVR\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x11ea056a0>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = np.linspace(0,2*np.pi,100).reshape(-1,1)\n",
    "y = np.sin(X)\n",
    "plt.scatter(X,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 线性核函数建模"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/xindors/Documents/workspace/hetonghai-projects/artificial-intelligence-code/.venv/lib/python3.13/site-packages/sklearn/utils/validation.py:1408: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x11eef4410>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = SVR(kernel='linear')\n",
    "model.fit(X,y)\n",
    "y_ = model.predict(X)\n",
    "plt.scatter(X,y_,color='red')\n",
    "plt.scatter(X,y,color='green')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### poly 多项式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/xindors/Documents/workspace/hetonghai-projects/artificial-intelligence-code/.venv/lib/python3.13/site-packages/sklearn/utils/validation.py:1408: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.23205291799121175"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = SVR(kernel='poly',degree=5)\n",
    "model.fit(X,y)\n",
    "y_ = model.predict(X)\n",
    "plt.scatter(X,y_,color='red')\n",
    "plt.scatter(X,y,color='green')\n",
    "model.score(X,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 高斯核函数rbf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/xindors/Documents/workspace/hetonghai-projects/artificial-intelligence-code/.venv/lib/python3.13/site-packages/sklearn/utils/validation.py:1408: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.9892073177718077"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = SVR(kernel='rbf')\n",
    "model.fit(X,y)\n",
    "y_ = model.predict(X)\n",
    "plt.scatter(X,y_,color='red')\n",
    "plt.scatter(X,y,color='green')\n",
    "model.score(X,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 天猫双十销量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 创建数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13 13\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x12298b750>"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.svm import SVR\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "X = np.arange(2009,2022) - 2008\n",
    "y = np.array([0,5,9,36,52,191,350,571,912,1207,1682,2135,2684])\n",
    "print(X.size,y.size)\n",
    "plt.scatter(X,y,color='red')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ],\n",
       "       [ 1.13131313],\n",
       "       [ 1.26262626],\n",
       "       [ 1.39393939],\n",
       "       [ 1.52525253],\n",
       "       [ 1.65656566],\n",
       "       [ 1.78787879],\n",
       "       [ 1.91919192],\n",
       "       [ 2.05050505],\n",
       "       [ 2.18181818],\n",
       "       [ 2.31313131],\n",
       "       [ 2.44444444],\n",
       "       [ 2.57575758],\n",
       "       [ 2.70707071],\n",
       "       [ 2.83838384],\n",
       "       [ 2.96969697],\n",
       "       [ 3.1010101 ],\n",
       "       [ 3.23232323],\n",
       "       [ 3.36363636],\n",
       "       [ 3.49494949],\n",
       "       [ 3.62626263],\n",
       "       [ 3.75757576],\n",
       "       [ 3.88888889],\n",
       "       [ 4.02020202],\n",
       "       [ 4.15151515],\n",
       "       [ 4.28282828],\n",
       "       [ 4.41414141],\n",
       "       [ 4.54545455],\n",
       "       [ 4.67676768],\n",
       "       [ 4.80808081],\n",
       "       [ 4.93939394],\n",
       "       [ 5.07070707],\n",
       "       [ 5.2020202 ],\n",
       "       [ 5.33333333],\n",
       "       [ 5.46464646],\n",
       "       [ 5.5959596 ],\n",
       "       [ 5.72727273],\n",
       "       [ 5.85858586],\n",
       "       [ 5.98989899],\n",
       "       [ 6.12121212],\n",
       "       [ 6.25252525],\n",
       "       [ 6.38383838],\n",
       "       [ 6.51515152],\n",
       "       [ 6.64646465],\n",
       "       [ 6.77777778],\n",
       "       [ 6.90909091],\n",
       "       [ 7.04040404],\n",
       "       [ 7.17171717],\n",
       "       [ 7.3030303 ],\n",
       "       [ 7.43434343],\n",
       "       [ 7.56565657],\n",
       "       [ 7.6969697 ],\n",
       "       [ 7.82828283],\n",
       "       [ 7.95959596],\n",
       "       [ 8.09090909],\n",
       "       [ 8.22222222],\n",
       "       [ 8.35353535],\n",
       "       [ 8.48484848],\n",
       "       [ 8.61616162],\n",
       "       [ 8.74747475],\n",
       "       [ 8.87878788],\n",
       "       [ 9.01010101],\n",
       "       [ 9.14141414],\n",
       "       [ 9.27272727],\n",
       "       [ 9.4040404 ],\n",
       "       [ 9.53535354],\n",
       "       [ 9.66666667],\n",
       "       [ 9.7979798 ],\n",
       "       [ 9.92929293],\n",
       "       [10.06060606],\n",
       "       [10.19191919],\n",
       "       [10.32323232],\n",
       "       [10.45454545],\n",
       "       [10.58585859],\n",
       "       [10.71717172],\n",
       "       [10.84848485],\n",
       "       [10.97979798],\n",
       "       [11.11111111],\n",
       "       [11.24242424],\n",
       "       [11.37373737],\n",
       "       [11.50505051],\n",
       "       [11.63636364],\n",
       "       [11.76767677],\n",
       "       [11.8989899 ],\n",
       "       [12.03030303],\n",
       "       [12.16161616],\n",
       "       [12.29292929],\n",
       "       [12.42424242],\n",
       "       [12.55555556],\n",
       "       [12.68686869],\n",
       "       [12.81818182],\n",
       "       [12.94949495],\n",
       "       [13.08080808],\n",
       "       [13.21212121],\n",
       "       [13.34343434],\n",
       "       [13.47474747],\n",
       "       [13.60606061],\n",
       "       [13.73737374],\n",
       "       [13.86868687],\n",
       "       [14.        ]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test = np.linspace(2009,2022,100).reshape(-1,1)-2008\n",
    "X_test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 线性函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x122b3a850>]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = SVR(kernel='linear')\n",
    "model.fit(X.reshape(-1,1),y)\n",
    "y_ = model.predict(X_test)\n",
    "plt.scatter(X,y,color='red')\n",
    "# plt.plot(X_test.ravel(),y_,color='green')\n",
    "plt.plot(X_test,y_,color='green')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 高斯核函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x122c2da90>]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = SVR(kernel='rbf')\n",
    "model.fit(X.reshape(-1,1),y)\n",
    "y_ = model.predict(X_test)\n",
    "plt.scatter(X,y,color='red')\n",
    "plt.plot(X_test.ravel(),y_,color='green')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### poly多项式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x122e4f390>]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = SVR(kernel='poly',degree=4,coef0=100) # coef0 表示截距\n",
    "model.fit(X.reshape(-1,1),y)\n",
    "y_ = model.predict(X_test)\n",
    "plt.scatter(X,y,color='red')\n",
    "plt.plot(X_test.ravel(),y_,color='green')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
